home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / GapText.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  12KB  |  600 lines
  1. //$GapText,GapTextIter$
  2. #include "GapText.h" 
  3. #include "RegularExp.h"
  4. #include "Port.h"
  5. #include "Error.h"
  6.  
  7. const int cShrinkFactor = 2,
  8.       cMaxOutput    = 500,
  9.       cInitialSize  = 16;
  10. char *cMemOverflow= "memory overflow",
  11.      *cGapTextName= "CheckPtr";
  12.  
  13. static TextChanges changeRec;
  14.  
  15. //---- GapText -----------------------------------------------------------------
  16.  
  17. MetaImpl(GapText, (T(size), T(length), T(part1len), T(gaplen),
  18.             TV(body, part1len), TV(body2, part2len), TP(font), 0));
  19.  
  20. void GapText::MoveGap(int to)
  21. {
  22.     if (to == part1len)
  23.     return;
  24.  
  25.     if (part1len > to)
  26.     BCOPY(body+to, body+to+gaplen, part1len-to);
  27.     else 
  28.     BCOPY(body+part1len+gaplen, body+part1len, to-part1len);
  29.  
  30.     part1len= to; 
  31. }            
  32.  
  33. void GapText::CopyTo(byte *dst, int from, int to)
  34. {
  35.     // Copy Text between 'from' and 'to' to 'dst'
  36.  
  37.     int beforegap= max(0, part1len-from) - max(0, part1len-to);
  38.     int aftergap = max(0, to - part1len) - max(0, from-part1len);
  39.  
  40.     if (beforegap) 
  41.     BCOPY(body+from, dst, beforegap);
  42.     if (aftergap)
  43.     BCOPY(part2body+max(part1len, from), dst+beforegap, aftergap);
  44. }
  45.  
  46. void GapText::Expand(int to, int moveto)
  47. { 
  48.     // Expand size of Text to 'to'
  49.     byte *pos, *part2;
  50.  
  51.     if (to == 0)
  52.     to= size * 2;
  53.  
  54.     if (to < size) 
  55.     return;
  56.  
  57.     if (moveto > length)
  58.     moveto= length;
  59.  
  60.     size= to;
  61.     pos= new byte[size];
  62.     CheckPtr(pos);
  63.     part2= pos + size -length;
  64.  
  65.     if (moveto < part1len) {
  66.     BCOPY(body, pos, moveto);
  67.     BCOPY(body + moveto, part2 + moveto, part1len - moveto);
  68.     BCOPY(part2body + part1len, part2 + part1len, length -part1len);
  69.     } else {
  70.     BCOPY(body, pos, part1len);
  71.     BCOPY(part2body + part1len, pos + part1len, moveto - part1len);
  72.     BCOPY(part2body + moveto, part2 + moveto, length - moveto);
  73.     }
  74.  
  75.     delete body;
  76.     body= pos;
  77.  
  78.     Update(moveto);
  79. }
  80.  
  81. void GapText::Shrink(int to)
  82. { 
  83.     // Reduce size of Text to 'to'
  84.     // If to = 0 then size = size / cShrinkFactor + 1
  85.  
  86.     byte *pos;
  87.  
  88.     if ((to == 0) || (to < length))
  89.     to= size / cShrinkFactor + 1;
  90.  
  91.     if ( (to > size) || (to < length) ) 
  92.     return;
  93.  
  94.     size= to;
  95.  
  96.     pos= new byte[size];
  97.     CheckPtr(pos);
  98.  
  99.     BCOPY(body, pos, part1len);
  100.     BCOPY(body+part1len+gaplen, pos+part1len, length-part1len);
  101.  
  102.     delete body;
  103.     body= pos;
  104.  
  105.     Update(length);
  106. }
  107.  
  108. GapText::GapText(int s, FontPtr fd)
  109. { 
  110.     size= max(cInitialSize, s);
  111.     body= new byte[size];
  112.     CheckPtr(body);
  113.     Init(0, fd);
  114. }
  115.  
  116. GapText::GapText(byte *buf, int len, bool ic, FontPtr fd)
  117. {   
  118.     if (len < 0)
  119.     len= strlen((char*)buf);
  120.     size= max(cInitialSize, len);
  121.     if (ic)
  122.     body= buf;
  123.     else {
  124.     body= new byte[size];
  125.     CheckPtr(body);
  126.     BCOPY(buf, body, len);
  127.     }
  128.     Init(len, fd);
  129. }
  130.  
  131. void GapText::Init(int l, FontPtr fd)
  132. {
  133.     length= l;
  134.     Update(l);
  135.     font= fd;
  136.     ink= ePatBlack;
  137.     SetTabWidth(fd->Width(' ')*8);
  138. }
  139.  
  140. GapText::~GapText()
  141. {
  142.     SafeDelete(body);
  143.     part2body= 0;
  144. }
  145.  
  146. void GapText::Paste(TextPtr paste,int from,int to)
  147. {
  148.     if (!CheckRange(length,from,to))
  149.     return;
  150.  
  151.     GapText *ft;
  152.     byte *buf= 0;
  153.  
  154.     if (!paste->IsKindOf(GapText)) {  // convert the text into a GapText
  155.     int s = paste->Size();
  156.     buf= new byte[s+1];
  157.     paste->CopyInStr(buf, s+1, 0, s);
  158.     ft= new GapText(buf, s, TRUE);
  159.     } else
  160.     ft= (GapText *)paste;
  161.  
  162.     int shift= ft->length - (to - from);
  163.  
  164.     if (HighWaterMark(shift))
  165.     Expand(GrowBy(size + shift), from);
  166.     else
  167.     MoveGap(from);
  168.  
  169.     ft->CopyTo(body+from, 0, ft->length);
  170.  
  171.     length    += shift;
  172.     gaplen    -= shift;
  173.     part1len  += ft->length;
  174.     part2body -= shift;
  175.     part2len= length - part1len;
  176.     body2= part2body + part1len;
  177.  
  178.     if (LowWaterMark())
  179.     Shrink();   
  180.     if (buf)
  181.     delete ft;
  182.     Text::Paste(paste, from, to);
  183.     Send(cIdNone, eTextReplaced, changeRec(from, to, paste->Size()));
  184. }
  185.  
  186. void GapText::Cut(int from,int to)
  187. {
  188.     int shift= to - from;
  189.  
  190.     if (!CheckRange(length, from, to))
  191.     return;
  192.  
  193.     if (from <= part1len && to >= part1len) // Gap is in between
  194.     part1len= from;
  195.     else  
  196.     MoveGap(from); 
  197.     length -= shift;
  198.     gaplen += shift;
  199.     part2body += shift;
  200.     part2len= length - part1len;
  201.     body2= part2body + part1len;
  202.  
  203.     if (LowWaterMark())
  204.     Shrink();
  205.  
  206.     Text::Cut(from,to);   
  207.     Send(cIdNone, eTextDeleted, changeRec(from, to));     
  208. }  
  209.  
  210. void GapText::Copy(Text *save,int from, int to)
  211. {
  212.     if (!CheckRange(length,from,to) || (save == 0))
  213.     return;
  214.  
  215.     if (!save->IsKindOf(GapText)){ // convert
  216.     int s= to -from ;
  217.     byte *buf= new byte[s+1];
  218.     CopyTo(buf, from, to); 
  219.     buf[to-from]= '\0';
  220.     save->ReplaceWithStr(buf,s); 
  221.     delete buf;
  222.     return;
  223.     }
  224.  
  225.     GapText *ft= (GapText*) save;
  226.     int nSize= to - from;
  227.  
  228.     ft->Empty();
  229.  
  230.     if (ft->size < nSize) 
  231.     ft->Expand(nSize, 0);
  232.  
  233.     CopyTo(ft->body, from, to);
  234.  
  235.     ft->length= to-from;
  236.     ft->Update(to-from);
  237. }
  238.  
  239. void GapText::CopyInStr(byte *str,int strsize,int from, int to)
  240. {
  241.     if (!CheckRange(length,from,to) || (str == 0))
  242.     return;
  243.     to= min(to,from + strsize-1);   
  244.     CopyTo(str, from, to);
  245.     str[to-from] = '\0';
  246. }
  247.  
  248. void GapText::ReplaceWithStr(byte *str, int len)
  249. {
  250.     if (len < 0)
  251.     len= strlen((char*)str);
  252.     Empty();
  253.     if (size < len) 
  254.     Expand(len,0);
  255.     BCOPY(str, body, len);
  256.     length= len;
  257.     Update(len);
  258. }
  259.  
  260. void GapText::SetFStringVL(char *fmt, va_list ap)
  261. {
  262.     Empty();
  263.     char *buf= strvprintf(fmt, ap);
  264.     int l= strlen(buf); 
  265.     if (size < l) 
  266.     Expand(l,0);
  267.     BCOPY((byte*)buf, body, l);
  268.     length= l;
  269.     Update(l);
  270.     SafeDelete(buf);
  271. }
  272.  
  273. int GapText::Search(RegularExp *rex, int *nMatched, int start, int range, 
  274.                          bool forward)
  275. {
  276.     int pos;
  277.  
  278.     if (forward) 
  279.     pos= rex->SearchForward2((char*)body, part1len,
  280.                         (char*)(body+part1len+gaplen), 
  281.             length-part1len, start, range, 0, nMatched);
  282.     else {
  283.     // BUG in RegularExp::SearchBackward2 ??
  284.     MoveGap(length);
  285.     pos= rex->SearchBackward((char*)body, nMatched, start, length, range, 0);
  286.     } 
  287.     return pos;
  288. }
  289.  
  290. byte *GapText::GetTextAt(int from, int to)
  291. {    
  292.     if (!CheckRange(length,from,to))
  293.     return 0;
  294.  
  295.     if ((part1len < to) && (part1len >= from))
  296.     // Gap is in between 
  297.     if ( part1len > (( to + from) >> 1) )   
  298.         MoveGap(to);
  299.     else
  300.         MoveGap(from);
  301.  
  302.     if (part1len < from) 
  303.     return &part2body[from];
  304.     return &body[from];
  305. }
  306.  
  307. TextPtr GapText::Save(int from, int to)
  308. {
  309.     if (!CheckRange(length,from,to))
  310.     return 0;
  311.  
  312.     GapText* t= new GapText(to-from);
  313.     Copy(t, from, to);
  314.     return t;
  315. }
  316.  
  317. void GapText::Insert(byte c, int from, int to)
  318. {
  319.     int shift= 1 - (to - from);
  320.  
  321.     if (!CheckRange(length,from,to))
  322.     return;
  323.  
  324.     if (HighWaterMark(shift))
  325.     Expand(GrowBy(size+shift), from);
  326.     else     
  327.     MoveGap(from);
  328.     body[from] = c;
  329.  
  330.     length    += shift;
  331.     gaplen    -= shift;
  332.     part1len  += shift;
  333.     part2body -= shift;
  334.     part2len= length - part1len;
  335.     body2= part2body + part1len;
  336.  
  337.     if (LowWaterMark())
  338.     Shrink();
  339.  
  340.     Text::Insert(c, from, to);
  341.     Send(cIdNone, eTextReplaced, changeRec(from, to, 1));     
  342. }
  343.  
  344. byte& GapText::operator[](int i)
  345. {
  346.     //----> should notify about possible changes but how?? 
  347.     i= min(i, length-1);
  348.     if (i < part1len)
  349.     return body[i];
  350.     return part2body[i];
  351. }
  352.  
  353. void GapText::Empty(int initSize)                                         
  354. {
  355.     if (initSize > 0) {
  356.     delete body;
  357.     body= new byte[size= initSize];
  358.     CheckPtr(body);
  359.     }
  360.     length= 0;
  361.     Update(0);
  362. }
  363.  
  364. bool GapText::IsEqual(ObjPtr text)                                         
  365. {
  366.     if (!text->IsKindOf(GapText))
  367.     return FALSE;
  368.     GapText *t= (GapText *) text; 
  369.  
  370.     if (length != t->length) 
  371.     return FALSE;
  372.  
  373.     MoveGap(length);
  374.     t->MoveGap(t->length);
  375.     return (strncmp((char*)body, (char*)t->body, length) == 0);
  376. }
  377.  
  378. int GapText::Size()
  379. { 
  380.     return length; 
  381. }                                         
  382.  
  383. bool GapText::IsEmpty()
  384. {   
  385.     return length == 0; 
  386. }
  387.  
  388. unsigned long GapText::Hash()                                         
  389. {
  390.     register unsigned long hash;
  391.     register byte *p;
  392.  
  393.     for (hash= 0, p= body; p < body+part1len; p++)
  394.     hash= (hash << 1) ^ *p;
  395.     for (p= body+part1len+gaplen; p < body+size; p++)
  396.     hash= (hash << 1) ^ *p;
  397.     return hash;
  398. }
  399.  
  400. bool GapText::IsEqualStr(byte *t)                                         
  401. {
  402.     if (length != strlen((char*)t)) 
  403.     return FALSE;
  404.     MoveGap(length);
  405.     return strncmp((char*)body, (char*)t, length) == 0;
  406. }
  407.  
  408. void GapText::Dump()
  409. {   
  410.     int i;
  411.     cerr << "size : " << size << "\n";
  412.     cerr << "length  : " << length << "\n";
  413.     cerr << "part1len     : " << part1len << "\n";
  414.     cerr << "gaplen  : " << gaplen << "\n";
  415.     cerr << "part2body-body    : " << int(part2body-body) << "\n";
  416.     cerr << "body  : ";
  417.     for (i=0 ; i < size ; i++){
  418.     if (i == part1len )
  419.         cerr << "[";
  420.     if (i == (part1len + gaplen))
  421.         cerr << "]";
  422.     if ((body[i]>= ' ') && (body[i] <='~'))
  423.         cerr.put(body[i]);
  424.     else
  425.         cerr << ".";
  426.     }
  427.     cerr << "\n" ;
  428. }
  429.  
  430. TextIter *GapText::MakeIterator(int from, int to)
  431. {
  432.     return new GapTextIter(this,from,to);
  433. }
  434.  
  435. ostream& GapText::PrintOn(ostream& s)
  436. {
  437.     Text::PrintOn(s);
  438.     s << font SP << ink SP; 
  439.     MoveGap(length);
  440.     return PrintString(s, body, length);
  441. }
  442.  
  443. istream& GapText::ReadFrom(istream& s)
  444. {
  445.     Text::ReadFrom(s);
  446.     s >> font >> ink;
  447.     SafeDelete(body);
  448.     ReadString(s, &body, &length);
  449.     size= length;
  450.     Update(length);
  451.     return s;
  452. }
  453.  
  454. ostream& GapText::PrintOnAsPureText(ostream& s)
  455. {
  456.     register int i;
  457.     for (i= 0; i < length; i++)
  458.     s.put(CharAt(i));
  459.     return s;
  460. }
  461.  
  462. istream& GapText::ReadFromAsPureText(istream& s, long sizeHint)
  463. {
  464.     char ch;
  465.  
  466.     if (sizeHint > 0 && ((int)(sizeHint - size)) > 0)
  467.     Expand(GrowBy((int)sizeHint + 50));
  468.     if (body == 0)
  469.     body= new byte[size= 1024];
  470.     length= 0;
  471.  
  472.     while (s.get(ch)) {
  473.     if (length >= size){
  474.         part2body= body ;
  475.         body= new byte[size= (size+1)*2];
  476.         CheckPtr(body);
  477.         BCOPY(part2body, body, length);
  478.         delete part2body;
  479.     }
  480.     body[length++]= ch;
  481.     }
  482.  
  483.     Update(length);
  484.  
  485.     if (!s.eof())
  486.     Error("ReadFromAsPureText", "something strange happended");
  487.     return s;
  488. }
  489.  
  490. int GapText::TextWidth(int from, int to)
  491. {
  492.     if (!CheckRange(length, from ,to))
  493.     return 0;
  494.  
  495.     register int i, w= 0;
  496.     register byte c;
  497.     for (i= from; i < to; i++) {
  498.     if ((c= CharAt(i)) == '\t') 
  499.         w+= Tabulate(w); 
  500.     else
  501.         w+= font->Width(c);
  502.     }
  503.     return w;
  504. }
  505.  
  506. void GapText::DrawText(int from, int to, Rectangle)
  507. {
  508.     if (!CheckRange(length, from ,to))
  509.     return;
  510.  
  511.     Point start= GrGetTextPos();
  512.     register int i;
  513.     register byte c;
  514.     SetDrawingState(from);
  515.     for (i= from; i < to; i++)
  516.     if ((c= CharAt(i)) == '\t') 
  517.         GrTextAdvance(Tabulate(GrGetTextPos().x-start.x)); 
  518.     else
  519.         GrDrawChar(c);
  520. } 
  521.  
  522. //---- GapTextIter -------------------------------------------------------------
  523.  
  524. GapTextIter::GapTextIter(Text *s, int from, int to) : TextIter(s, from, to)
  525. {
  526.     if (!s->IsKindOf(GapText))
  527.     Error("GapTextIter::Error", "GapText expected (%s received)", s->ClassName());
  528.     font= s->GetFont();
  529. } 
  530.  
  531. int GapTextIter::operator()()
  532. { 
  533.     return (ce == upto ? cEOT : ((GapText*)ct)->CharAt(ce++)); 
  534. }
  535.  
  536. int GapTextIter::operator()(int *w, LineDesc *ld)  
  537. {
  538.     register GapTextPtr pt= GapTextPtr(ct);
  539.     int ch;
  540.  
  541.     if (ld) 
  542.     ld->FromFont(font);
  543.     *w= 0;
  544.     if (ce == upto )
  545.     return cEOT;
  546.     ch= GapTextPtr(ct)->CharAt(ce++);
  547.     *w= font->Width(ch);
  548.     return ch;
  549. }
  550.  
  551. int GapTextIter::Line(LineDesc *ld)
  552. {
  553.     register GapTextPtr pt = GapTextPtr(ct);
  554.     if (ld) 
  555.     ld->FromFont(font);
  556.     unget= ce;
  557.     if (ce == upto) {
  558.     // special case if last line is empty
  559.     int last= GapTextPtr(ct)->CharAt(ce-1);
  560.     ce++;
  561.     if (last == '\n' || last == '\r')
  562.         return upto;
  563.     }
  564.     if (ce > upto)
  565.     return cEOT;
  566.  
  567.     while (ce < upto) {
  568.     int ch= GapTextPtr(ct)->CharAt(ce++);
  569.     if (ch == '\n' || ch == '\r')
  570.         break;
  571.     }
  572.     return ce;
  573. }
  574.  
  575. int GapTextIter::Token(int *w, LineDesc *ld)
  576. {
  577.     unget= ce;
  578.     register GapTextPtr pt= GapTextPtr(ct);
  579.  
  580.     *w= 0;
  581.     if (ld) 
  582.     ld->FromFont(font);
  583.  
  584.     if (ce >= upto)
  585.     return cEOT;
  586.  
  587.     register int ch= pt->CharAt(ce);
  588.     if (Isspace(ch)) {
  589.     *w= font->Width(ch);
  590.     ce++;
  591.     return ch;
  592.     }
  593.     while (ce < upto && !Isspace(pt->CharAt(ce))) {
  594.     ch= pt->CharAt(ce++);
  595.     *w += font->Width(ch);
  596.     }
  597.  
  598.     return ch;
  599. }
  600.